import 'dart:convert';
import 'package:http/http.dart' as http;
import '../models/question.dart';

class ApiService {
  static const String baseUrl = 'http://127.0.0.1:8000';

  // 模拟分析结果的模板
  // static const List<String> _analysisTemplates = [
  //   '您的心理健康状况整体表现良好',
  //   '您在某些方面可能需要更多关注',
  //   '建议您寻求专业心理咨询帮助',
  //   '您的心理状态需要积极调整',
  // ];

  // 提交问卷数据并获取分析结果
  Future<Map<String, dynamic>> submitAssessment({
    required Map<String, dynamic> basicInfo,
    required Map<String, int> sclAnswers,
  }) async {
    try {
      final response = await http
          .post(
            Uri.parse('$baseUrl/api/submit/'),
            headers: {'Content-Type': 'application/json'},
            body: jsonEncode({
              'basic_info': basicInfo,
              'scl_answers': sclAnswers,
            }),
          )
          .timeout(const Duration(seconds: 300));

      if (response.statusCode == 200) {
        final data = jsonDecode(response.body);
        // 如果响应中包含analysis字段，将Markdown转换为纯文本
        if (data['analysis'] != null && data['analysis'] is String) {
          data['analysis'] = _convertMarkdownToPlainText(data['analysis']);
        }
        return data;
      } else {
        throw Exception('提交失败: ${response.statusCode}');
      }
    } catch (e) {
      // 如果API调用失败，使用模拟分析
      return await _generateMockResponse(basicInfo, sclAnswers);
    }
  }

  // 模拟响应生成
  Future<Map<String, dynamic>> _generateMockResponse(
    Map<String, dynamic> basicInfo,
    Map<String, int> sclAnswers,
  ) async {
    await Future.delayed(const Duration(seconds: 2)); // 模拟网络延迟

    // 计算SCL-90因子得分
    final factorScores = _calculateFactorScores(sclAnswers);

    // 生成分析报告
    final analysisReport = _generatePersonalizedReport(basicInfo, factorScores);

    // 生成测试ID
    final testId = DateTime.now().millisecondsSinceEpoch.toString();

    return {
      'success': true,
      'test_id': testId,
      'analysis': analysisReport,
      'short_url': 'https://paf.demo/r/$testId',
    };
  }

  // 计算SCL-90因子得分
  Map<String, double> _calculateFactorScores(Map<String, int> sclAnswers) {
    final factors = QuestionnaireData.getSCLFactors();
    Map<String, double> factorScores = {};

    for (String factor in factors.keys) {
      List<int> questionIds = factors[factor]!;
      double totalScore = 0;
      int answeredCount = 0;

      for (int questionId in questionIds) {
        if (sclAnswers.containsKey(questionId.toString())) {
          int score = sclAnswers[questionId.toString()]!;
          totalScore += score - 1; // 转换为0-4分制
          answeredCount++;
        }
      }

      if (answeredCount > 0) {
        factorScores[factor] = totalScore / answeredCount;
      } else {
        factorScores[factor] = 0.0;
      }
    }

    return factorScores;
  }

  // 计算总体得分 (暂未使用)
  // double _calculateOverallScore(Map<String, double> factorScores) {
  //   if (factorScores.isEmpty) return 0.0;
  //   return factorScores.values.reduce((a, b) => a + b) / factorScores.length;
  // }

  // 计算SCL-90总分 (暂未使用)
  // Map<String, double> _calculateTotalScore(Map<String, int> sclAnswers) {
  //   double totalScore = 0;
  //   int answeredCount = 0;
  //   for (int i = 1; i <= 90; i++) {
  //     if (sclAnswers.containsKey(i.toString())) {
  //       int score = sclAnswers[i.toString()]!;
  //       totalScore += score;
  //       answeredCount++;
  //     }
  //   }
  //   return {
  //     '总分': answeredCount > 0 ? totalScore : 0.0,
  //     '平均分': answeredCount > 0 ? totalScore / answeredCount : 0.0,
  //   };
  // }

  // 生成个性化报告（总分模式）
  String _generatePersonalizedReport(
    Map<String, dynamic> basicInfo,
    Map<String, double> totalScores,
  ) {
    final StringBuffer report = StringBuffer();
    report.writeln('🌟 心理健康评估报告');
    report.writeln('=' * 25);
    report.writeln();
    report.writeln('📊 基本信息：');
    report.writeln('年龄：${basicInfo['age']}');
    report.writeln('性别：${basicInfo['gender']}');
    report.writeln('职业：${basicInfo['occupation']}');
    report.writeln('睡眠状况：${basicInfo['sleep_condition']}');
    report.writeln();
    double totalScore = totalScores['总分'] ?? 0.0;
    double averageScore = totalScores['平均分'] ?? 0.0;
    final level = _getTotalScoreLevel(totalScore);
    final suggestion = _getTotalScoreSuggestion(totalScore);
    report.writeln('🎯 评估结果：');
    report.writeln('总分：${totalScore.toInt()}分（满分450分）');
    report.writeln('平均分：${averageScore.toStringAsFixed(2)}分');
    report.writeln('心理状态解读：$level');
    report.writeln('建议说明：$suggestion');
    report.writeln();
    report.writeln('💡 个性化建议：');
    report.writeln(_getPersonalizedSuggestions(basicInfo, totalScores));
    report.writeln();
    report.writeln('🏥 紧急联系：');
    report.writeln('如果您有自伤或自杀的想法，请立即联系：');
    report.writeln('• 全国心理危机干预热线：400-161-9995');
    report.writeln('• 北京心理危机研究与干预中心：010-82951332');
    report.writeln('• 上海心理援助热线：021-34289888');
    return report.toString();
  }

  // 获取整体水平描述 (暂未使用)
  // String _getOverallLevel(double score) {
  //   if (score < 1.0) return '良好';
  //   if (score < 1.5) return '一般';
  //   if (score < 2.0) return '需要关注';
  //   if (score < 2.5) return '需要帮助';
  //   return '需要专业干预';
  // }

  // 获取因子水平描述 (暂未使用)
  // String _getFactorLevel(double score) {
  //   if (score < 1.0) return '正常';
  //   if (score < 1.5) return '轻微';
  //   if (score < 2.0) return '中等';
  //   if (score < 2.5) return '较重';
  //   return '严重';
  // }

  // 获取因子建议 (暂未使用)
  // String _getFactorSuggestion(String factor, double score) {
  //   if (score < 1.0) return '保持现状';
  //
  //   switch (factor) {
  //     case '躯体化':
  //       return '注意身体健康，进行适当运动';
  //     case '强迫症状':
  //       return '学习放松技巧，减少完美主义倾向';
  //     case '人际关系敏感':
  //       return '提高社交技能，建立良好人际关系';
  //     case '抑郁':
  //       return '寻求支持，参与愉快活动';
  //     case '焦虑':
  //       return '学习焦虑管理技巧，进行深呼吸练习';
  //     case '敌对':
  //       return '学习情绪管理，培养耐心';
  //     case '恐怖':
  //       return '逐步暴露治疗，寻求专业帮助';
  //     case '偏执':
  //       return '增强现实检验能力，改善认知';
  //     case '精神病性':
  //       return '寻求专业精神科医生帮助';
  //     default:
  //       return '建议寻求专业指导';
  //   }
  // }

  // 获取个性化建议
  String _getPersonalizedSuggestions(
    Map<String, dynamic> basicInfo,
    Map<String, double> factorScores,
  ) {
    final StringBuffer suggestions = StringBuffer();

    // 基于年龄的建议
    String age = basicInfo['age'] as String;
    if (age.contains('18-25')) {
      suggestions.writeln('• 作为年轻人，建议建立良好的生活习惯和社交圈子');
    } else if (age.contains('26-35')) {
      suggestions.writeln('• 工作压力较大的年龄段，注意工作生活平衡');
    } else if (age.contains('36-45')) {
      suggestions.writeln('• 中年期注意家庭和职业双重压力的管理');
    } else if (age.contains('46-55')) {
      suggestions.writeln('• 关注身体健康变化对心理的影响');
    } else if (age.contains('56-65')) {
      suggestions.writeln('• 注意退休前后的心理适应');
    }

    // 基于职业的建议
    String occupation = basicInfo['occupation'] as String;
    switch (occupation) {
      case '学生':
        suggestions.writeln('• 学习压力管理，建立良好的学习习惯');
        break;
      case '医护人员':
        suggestions.writeln('• 注意职业倦怠，寻求同事支持');
        break;
      case '教师':
        suggestions.writeln('• 平衡工作和个人生活，注意嗓子保护');
        break;
      case '企业员工':
        suggestions.writeln('• 注意工作压力，定期进行身心放松');
        break;
    }

    // 基于睡眠的建议
    String sleep = basicInfo['sleep_condition'] as String;
    if (sleep.contains('失眠')) {
      suggestions.writeln('• 建立规律的睡眠时间，避免睡前使用电子设备');
      suggestions.writeln('• 可以尝试放松技巧如冥想、深呼吸等');
    }

    return suggestions.toString();
  }

  // 获取评估结果 (暂未使用)
  // Future<Map<String, dynamic>> getResult(String testId) async {
  //   try {
  //     final response = await http
  //         .get(Uri.parse('$baseUrl/api/result/$testId/'))
  //         .timeout(const Duration(seconds: 300));
  //
  //     if (response.statusCode == 200) {
  //       return jsonDecode(response.body);
  //     } else {
  //       throw Exception('获取结果失败: ${response.statusCode}');
  //     }
  //   } catch (e) {
  //     throw Exception('网络错误: $e');
  //   }
  // }

  // 获取短链接 (暂未使用)
  // Future<String> getShortLink(String testId) async {
  //   try {
  //     final response = await http
  //         .get(Uri.parse('$baseUrl/api/shortlink/?test_id=$testId'))
  //         .timeout(const Duration(seconds: 300));
  //
  //     if (response.statusCode == 200) {
  //       final data = jsonDecode(response.body);
  //       return data['short_url'] ?? 'https://paf.demo/r/$testId';
  //     }
  //   } catch (e) {
  //     // 模拟生成短链接
  //     return 'https://paf.demo/r/$testId';
  //   }
  //
  //   return 'https://paf.demo/r/$testId';
  // }

  // 获取结果短链接
  Future<String> getResultShortLink(String testId) async {
    try {
      final response = await http
          .get(Uri.parse('$baseUrl/api/result/shortlink/?test_id=$testId'))
          .timeout(const Duration(seconds: 300));

      if (response.statusCode == 200) {
        final data = jsonDecode(response.body);
        return data['short_url'] ?? 'https://paf.demo/r/$testId';
      }
    } catch (e) {
      // 模拟生成短链接
      return 'https://paf.demo/r/$testId';
    }

    return 'https://paf.demo/r/$testId';
  }

  // 系统健康检查 (暂未使用)
  // Future<Map<String, dynamic>> healthCheck() async {
  //   try {
  //     final response = await http
  //         .get(Uri.parse('$baseUrl/api/health/'))
  //         .timeout(const Duration(seconds: 300));
  //
  //     if (response.statusCode == 200) {
  //       return jsonDecode(response.body);
  //     } else {
  //       throw Exception('健康检查失败: ${response.statusCode}');
  //     }
  //   } catch (e) {
  //     throw Exception('网络错误: $e');
  //   }
  // }

  // 模拟DeepSeek AI分析 (暂未使用)
  // Future<String> _callDeepSeekAPI(Map<String, dynamic> testData) async {
  //   // 这里可以集成DeepSeek API
  //   // 需要配置API密钥和端点
  //   try {
  //     final response = await http
  //         .post(
  //           Uri.parse('https://api.deepseek.com/v1/chat/completions'),
  //           headers: {
  //             'Content-Type': 'application/json',
  //             'Authorization': 'Bearer YOUR_DEEPSEEK_API_KEY',
  //           },
  //           body: jsonEncode({
  //             'model': 'deepseek-chat',
  //             'messages': [
  //               {
  //                 'role': 'system',
  //                 'content': '你是一个专业的心理健康分析师，基于SCL-90问卷结果提供专业的心理健康评估。',
  //               },
  //               {
  //                 'role': 'user',
  //                 'content': '请分析以下SCL-90问卷结果：${jsonEncode(testData)}',
  //               },
  //             ],
  //             'max_tokens': 1000,
  //             'temperature': 0.7,
  //           }),
  //         )
  //         .timeout(const Duration(seconds: 300));
  //
  //     if (response.statusCode == 200) {
  //       final data = jsonDecode(response.body);
  //       return data['choices'][0]['message']['content'];
  //     }
  //   } catch (e) {
  //     print('DeepSeek API调用失败: $e');
  //   }
  //
  //   // 如果API调用失败，返回null使用模拟分析
  //   return '';
  // }

  // 根据总分获取心理状态解读
  String _getTotalScoreLevel(double score) {
    if (score <= 180) return '✅ 正常';
    if (score <= 270) return '⚠️ 轻度困扰';
    if (score <= 360) return '❗️中度困扰';
    if (score <= 405) return '❗️较重困扰';
    return '🚨 严重困扰';
  }

  // 根据总分获取建议
  String _getTotalScoreSuggestion(double score) {
    if (score <= 180) return '情绪稳定、心理状态良好，无明显困扰';
    if (score <= 270) return '可能有部分压力或不适，建议适当调节情绪';
    if (score <= 360) return '明显困扰，建议重视心理调节，可考虑咨询';
    if (score <= 405) return '情绪状态较差，日常功能可能受影响，建议咨询专业人士';
    return '情绪压力非常大，强烈建议寻求心理帮助或干预';
  }

  // 将Markdown格式转换为纯文本
  String _convertMarkdownToPlainText(String markdown) {
    String plainText = markdown;
    
    // 移除Markdown标题标记 (# ## ### ####)
    plainText = plainText.replaceAll(RegExp(r'^#{1,6}\s+', multiLine: true), '');
    
    // 移除粗体标记 (**text** 或 __text__)
    plainText = plainText.replaceAll(RegExp(r'\*\*(.*?)\*\*'), r'$1');
    plainText = plainText.replaceAll(RegExp(r'__(.*?)__'), r'$1');
    
    // 移除斜体标记 (*text* 或 _text_)
    plainText = plainText.replaceAll(RegExp(r'\*(.*?)\*'), r'$1');
    plainText = plainText.replaceAll(RegExp(r'_(.*?)_'), r'$1');
    
    // 移除删除线标记 (~~text~~)
    plainText = plainText.replaceAll(RegExp(r'~~(.*?)~~'), r'$1');
    
    // 移除行内代码标记 (`code`)
    plainText = plainText.replaceAll(RegExp(r'`([^`]+)`'), r'$1');
    
    // 移除代码块标记 (```code```)
    plainText = plainText.replaceAll(RegExp(r'```[\s\S]*?```'), '');
    
    // 移除链接标记 [text](url)
    plainText = plainText.replaceAll(RegExp(r'\[([^\]]+)\]\([^)]+\)'), r'$1');
    
    // 移除图片标记 ![alt](url)
    plainText = plainText.replaceAll(RegExp(r'!\[([^\]]*)\]\([^)]+\)'), r'$1');
    
    // 移除水平分割线
    plainText = plainText.replaceAll(RegExp(r'^-{3,}$', multiLine: true), '');
    plainText = plainText.replaceAll(RegExp(r'^\*{3,}$', multiLine: true), '');
    plainText = plainText.replaceAll(RegExp(r'^_{3,}$', multiLine: true), '');
    
    // 移除引用标记 (> text)
    plainText = plainText.replaceAll(RegExp(r'^>\s*', multiLine: true), '');
    
    // 移除列表标记 (- * + 开头的行)
    plainText = plainText.replaceAll(RegExp(r'^[\s]*[-*+]\s+', multiLine: true), '');
    
    // 移除有序列表标记 (1. 2. 等)
    plainText = plainText.replaceAll(RegExp(r'^[\s]*\d+\.\s+', multiLine: true), '');
    
    // 移除表格分隔符
    plainText = plainText.replaceAll(RegExp(r'\|'), '');
    
    // 清理多余的空行，保留段落结构
    plainText = plainText.replaceAll(RegExp(r'\n\s*\n\s*\n'), '\n\n');
    
    // 移除行首行尾的空白字符
    plainText = plainText.trim();
    
    return plainText;
  }
}
